#region Apache License
//
// Licensed to the Apache Software Foundation (ASF) under one or more 
// contributor license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright ownership. 
// The ASF licenses this file to you under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with 
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#endregion

// MONO 1.0 Beta mcs does not like #if !A && !B && !C syntax

// .NET Compact Framework 1.0 has no support for EventLog
#if !NETCF 
// SSCLI 1.0 has no support for EventLog
#if !SSCLI

using log4net.Core;
using log4net.Layout;
using log4net.Util;
using System;
using System.Diagnostics;

namespace log4net.Appender
{
    /// <summary>
    /// Writes events to the system event log.
    /// </summary>
    /// <remarks>
    /// <para>
    /// The appender will fail if you try to write using an event source that doesn't exist unless it is running with local administrator privileges.
    /// See also http://logging.apache.org/log4net/release/faq.html#trouble-EventLog
    /// </para>
    /// <para>
    /// The <c>EventID</c> of the event log entry can be
    /// set using the <c>EventID</c> property (<see cref="LoggingEvent.Properties"/>)
    /// on the <see cref="LoggingEvent"/>.
    /// </para>
    /// <para>
    /// The <c>Category</c> of the event log entry can be
    /// set using the <c>Category</c> property (<see cref="LoggingEvent.Properties"/>)
    /// on the <see cref="LoggingEvent"/>.
    /// </para>
    /// <para>
    /// There is a limit of 32K characters for an event log message
    /// </para>
    /// <para>
    /// When configuring the EventLogAppender a mapping can be
    /// specified to map a logging level to an event log entry type. For example:
    /// </para>
    /// <code lang="XML">
    /// &lt;mapping&gt;
    /// 	&lt;level value="ERROR" /&gt;
    /// 	&lt;eventLogEntryType value="Error" /&gt;
    /// &lt;/mapping&gt;
    /// &lt;mapping&gt;
    /// 	&lt;level value="DEBUG" /&gt;
    /// 	&lt;eventLogEntryType value="Information" /&gt;
    /// &lt;/mapping&gt;
    /// </code>
    /// <para>
    /// The Level is the standard log4net logging level and eventLogEntryType can be any value
    /// from the <see cref="EventLogEntryType"/> enum, i.e.:
    /// <list type="bullet">
    /// <item><term>Error</term><description>an error event</description></item>
    /// <item><term>Warning</term><description>a warning event</description></item>
    /// <item><term>Information</term><description>an informational event</description></item>
    /// </list>
    /// </para>
    /// </remarks>
    /// <author>Aspi Havewala</author>
    /// <author>Douglas de la Torre</author>
    /// <author>Nicko Cadell</author>
    /// <author>Gert Driesen</author>
    /// <author>Thomas Voss</author>
    public class EventLogAppender : AppenderSkeleton
    {
        #region Public Instance Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="EventLogAppender" /> class.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Default constructor.
        /// </para>
        /// </remarks>
        public EventLogAppender()
        {
            m_applicationName = System.Threading.Thread.GetDomain().FriendlyName;
            m_logName = "Application";  // Defaults to application log
            m_machineName = ".";    // Only log on the local machine
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="EventLogAppender" /> class
        /// with the specified <see cref="ILayout" />.
        /// </summary>
        /// <param name="layout">The <see cref="ILayout" /> to use with this appender.</param>
        /// <remarks>
        /// <para>
        /// Obsolete constructor.
        /// </para>
        /// </remarks>
        [Obsolete("Instead use the default constructor and set the Layout property")]
        public EventLogAppender(ILayout layout) : this()
        {
            Layout = layout;
        }

        #endregion // Public Instance Constructors

        #region Public Instance Properties

        /// <summary>
        /// The name of the log where messages will be stored.
        /// </summary>
        /// <value>
        /// The string name of the log where messages will be stored.
        /// </value>
        /// <remarks>
        /// <para>This is the name of the log as it appears in the Event Viewer
        /// tree. The default value is to log into the <c>Application</c>
        /// log, this is where most applications write their events. However
        /// if you need a separate log for your application (or applications)
        /// then you should set the <see cref="LogName"/> appropriately.</para>
        /// <para>This should not be used to distinguish your event log messages
        /// from those of other applications, the <see cref="ApplicationName"/>
        /// property should be used to distinguish events. This property should be 
        /// used to group together events into a single log.
        /// </para>
        /// </remarks>
        public string LogName
        {
            get { return m_logName; }
            set { m_logName = value; }
        }

        /// <summary>
        /// Property used to set the Application name.  This appears in the
        /// event logs when logging.
        /// </summary>
        /// <value>
        /// The string used to distinguish events from different sources.
        /// </value>
        /// <remarks>
        /// Sets the event log source property.
        /// </remarks>
        public string ApplicationName
        {
            get { return m_applicationName; }
            set { m_applicationName = value; }
        }

        /// <summary>
        /// This property is used to return the name of the computer to use
        /// when accessing the event logs.  Currently, this is the current
        /// computer, denoted by a dot "."
        /// </summary>
        /// <value>
        /// The string name of the machine holding the event log that 
        /// will be logged into.
        /// </value>
        /// <remarks>
        /// This property cannot be changed. It is currently set to '.'
        /// i.e. the local machine. This may be changed in future.
        /// </remarks>
        public string MachineName
        {
            get { return m_machineName; }
            set { /* Currently we do not allow the machine name to be changed */; }
        }

        /// <summary>
        /// Add a mapping of level to <see cref="EventLogEntryType"/> - done by the config file
        /// </summary>
        /// <param name="mapping">The mapping to add</param>
        /// <remarks>
        /// <para>
        /// Add a <see cref="Level2EventLogEntryType"/> mapping to this appender.
        /// Each mapping defines the event log entry type for a level.
        /// </para>
        /// </remarks>
        public void AddMapping(Level2EventLogEntryType mapping)
        {
            m_levelMapping.Add(mapping);
        }

        /// <summary>
        /// Gets or sets the <see cref="SecurityContext"/> used to write to the EventLog.
        /// </summary>
        /// <value>
        /// The <see cref="SecurityContext"/> used to write to the EventLog.
        /// </value>
        /// <remarks>
        /// <para>
        /// The system security context used to write to the EventLog.
        /// </para>
        /// <para>
        /// Unless a <see cref="SecurityContext"/> specified here for this appender
        /// the <see cref="SecurityContextProvider.DefaultProvider"/> is queried for the
        /// security context to use. The default behavior is to use the security context
        /// of the current thread.
        /// </para>
        /// </remarks>
        public SecurityContext SecurityContext
        {
            get { return m_securityContext; }
            set { m_securityContext = value; }
        }

        /// <summary>
        /// Gets or sets the <c>EventId</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
        /// </summary>
        /// <remarks>
        /// <para>
        /// The <c>EventID</c> of the event log entry will normally be
	    /// set using the <c>EventID</c> property (<see cref="LoggingEvent.Properties"/>)
	    /// on the <see cref="LoggingEvent"/>.
        /// This property provides the fallback value which defaults to 0.
        /// </para>
        /// </remarks>
        public int EventId
        {
            get { return m_eventId; }
            set { m_eventId = value; }
        }


        /// <summary>
        /// Gets or sets the <c>Category</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
        /// </summary>
        /// <remarks>
        /// <para>
        /// The <c>Category</c> of the event log entry will normally be
	    /// set using the <c>Category</c> property (<see cref="LoggingEvent.Properties"/>)
	    /// on the <see cref="LoggingEvent"/>.
        /// This property provides the fallback value which defaults to 0.
        /// </para>
        /// </remarks>
        public short Category
        {
            get { return m_category; }
            set { m_category = value; }
        }
        #endregion // Public Instance Properties

        #region Implementation of IOptionHandler

        /// <summary>
        /// Initialize the appender based on the options set
        /// </summary>
        /// <remarks>
        /// <para>
        /// This is part of the <see cref="IOptionHandler"/> delayed object
        /// activation scheme. The <see cref="ActivateOptions"/> method must 
        /// be called on this object after the configuration properties have
        /// been set. Until <see cref="ActivateOptions"/> is called this
        /// object is in an undefined state and must not be used. 
        /// </para>
        /// <para>
        /// If any of the configuration properties are modified then 
        /// <see cref="ActivateOptions"/> must be called again.
        /// </para>
        /// </remarks>
        override public void ActivateOptions()
        {
            try
            {
                base.ActivateOptions();

                if (m_securityContext == null)
                {
                    m_securityContext = SecurityContextProvider.DefaultProvider.CreateSecurityContext(this);
                }

                bool sourceAlreadyExists = false;
                string currentLogName = null;

                using (SecurityContext.Impersonate(this))
                {
                    sourceAlreadyExists = EventLog.SourceExists(m_applicationName);
                    if (sourceAlreadyExists)
                    {
                        currentLogName = EventLog.LogNameFromSourceName(m_applicationName, m_machineName);
                    }
                }

                if (sourceAlreadyExists && currentLogName != m_logName)
                {
                    LogLog.Debug(declaringType, "Changing event source [" + m_applicationName + "] from log [" + currentLogName + "] to log [" + m_logName + "]");
                }
                else if (!sourceAlreadyExists)
                {
                    LogLog.Debug(declaringType, "Creating event source Source [" + m_applicationName + "] in log " + m_logName + "]");
                }

                string registeredLogName = null;

                using (SecurityContext.Impersonate(this))
                {
                    if (sourceAlreadyExists && currentLogName != m_logName)
                    {
                        //
                        // Re-register this to the current application if the user has changed
                        // the application / logfile association
                        //
                        EventLog.DeleteEventSource(m_applicationName, m_machineName);
                        CreateEventSource(m_applicationName, m_logName, m_machineName);

                        registeredLogName = EventLog.LogNameFromSourceName(m_applicationName, m_machineName);
                    }
                    else if (!sourceAlreadyExists)
                    {
                        CreateEventSource(m_applicationName, m_logName, m_machineName);

                        registeredLogName = EventLog.LogNameFromSourceName(m_applicationName, m_machineName);
                    }
                }

                m_levelMapping.ActivateOptions();

                LogLog.Debug(declaringType, "Source [" + m_applicationName + "] is registered to log [" + registeredLogName + "]");
            }
            catch (System.Security.SecurityException ex)
            {
                ErrorHandler.Error("Caught a SecurityException trying to access the EventLog.  Most likely the event source "
                    + m_applicationName
                    + " doesn't exist and must be created by a local administrator.  Will disable EventLogAppender."
                    + "  See http://logging.apache.org/log4net/release/faq.html#trouble-EventLog",
                    ex);
                Threshold = Level.Off;
            }
        }

        #endregion // Implementation of IOptionHandler

        /// <summary>
        /// Create an event log source
        /// </summary>
        /// <remarks>
        /// Uses different API calls under NET_2_0
        /// </remarks>
        private static void CreateEventSource(string source, string logName, string machineName)
        {
#if NET_2_0
			EventSourceCreationData eventSourceCreationData = new EventSourceCreationData(source, logName);
			eventSourceCreationData.MachineName = machineName;
			EventLog.CreateEventSource(eventSourceCreationData);
#else
            EventLog.CreateEventSource(source, logName, machineName);
#endif
        }

        #region Override implementation of AppenderSkeleton

        /// <summary>
        /// This method is called by the <see cref="AppenderSkeleton.DoAppend(LoggingEvent)"/>
        /// method. 
        /// </summary>
        /// <param name="loggingEvent">the event to log</param>
        /// <remarks>
        /// <para>Writes the event to the system event log using the 
        /// <see cref="ApplicationName"/>.</para>
        /// 
        /// <para>If the event has an <c>EventID</c> property (see <see cref="LoggingEvent.Properties"/>)
        /// set then this integer will be used as the event log event id.</para>
        /// 
        /// <para>
        /// There is a limit of 32K characters for an event log message
        /// </para>
        /// </remarks>
        override protected void Append(LoggingEvent loggingEvent)
        {
            //
            // Write the resulting string to the event log system
            //
            int eventID = m_eventId;

            // Look for the EventID property
            object eventIDPropertyObj = loggingEvent.LookupProperty("EventID");
            if (eventIDPropertyObj != null)
            {
                if (eventIDPropertyObj is int)
                {
                    eventID = (int)eventIDPropertyObj;
                }
                else
                {
                    string eventIDPropertyString = eventIDPropertyObj as string;
                    if (eventIDPropertyString == null)
                    {
                        eventIDPropertyString = eventIDPropertyObj.ToString();
                    }
                    if (eventIDPropertyString != null && eventIDPropertyString.Length > 0)
                    {
                        // Read the string property into a number
                        int intVal;
                        if (SystemInfo.TryParse(eventIDPropertyString, out intVal))
                        {
                            eventID = intVal;
                        }
                        else
                        {
                            ErrorHandler.Error("Unable to parse event ID property [" + eventIDPropertyString + "].");
                        }
                    }
                }
            }

            short category = m_category;
            // Look for the Category property
            object categoryPropertyObj = loggingEvent.LookupProperty("Category");
            if (categoryPropertyObj != null)
            {
                if (categoryPropertyObj is short)
                {
                    category = (short)categoryPropertyObj;
                }
                else
                {
                    string categoryPropertyString = categoryPropertyObj as string;
                    if (categoryPropertyString == null)
                    {
                        categoryPropertyString = categoryPropertyObj.ToString();
                    }
                    if (categoryPropertyString != null && categoryPropertyString.Length > 0)
                    {
                        // Read the string property into a number
                        short shortVal;
                        if (SystemInfo.TryParse(categoryPropertyString, out shortVal))
                        {
                            category = shortVal;
                        }
                        else
                        {
                            ErrorHandler.Error("Unable to parse event category property [" + categoryPropertyString + "].");
                        }
                    }
                }
            }

            // Write to the event log
            try
            {
                string eventTxt = RenderLoggingEvent(loggingEvent);

                // There is a limit of 32K characters for an event log message
                if (eventTxt.Length > 32000)
                {
                    eventTxt = eventTxt.Substring(0, 32000);
                }

                EventLogEntryType entryType = GetEntryType(loggingEvent.Level);

                using (SecurityContext.Impersonate(this))
                {
                    EventLog.WriteEntry(m_applicationName, eventTxt, entryType, eventID, category);
                }
            }
            catch (Exception ex)
            {
                ErrorHandler.Error("Unable to write to event log [" + m_logName + "] using source [" + m_applicationName + "]", ex);
            }
        }

        /// <summary>
        /// This appender requires a <see cref="Layout"/> to be set.
        /// </summary>
        /// <value><c>true</c></value>
        /// <remarks>
        /// <para>
        /// This appender requires a <see cref="Layout"/> to be set.
        /// </para>
        /// </remarks>
        override protected bool RequiresLayout
        {
            get { return true; }
        }

        #endregion // Override implementation of AppenderSkeleton

        #region Protected Instance Methods

        /// <summary>
        /// Get the equivalent <see cref="EventLogEntryType"/> for a <see cref="Level"/> <paramref name="level"/>
        /// </summary>
        /// <param name="level">the Level to convert to an EventLogEntryType</param>
        /// <returns>The equivalent <see cref="EventLogEntryType"/> for a <see cref="Level"/> <paramref name="level"/></returns>
        /// <remarks>
        /// Because there are fewer applicable <see cref="EventLogEntryType"/>
        /// values to use in logging levels than there are in the 
        /// <see cref="Level"/> this is a one way mapping. There is
        /// a loss of information during the conversion.
        /// </remarks>
        virtual protected EventLogEntryType GetEntryType(Level level)
        {
            // see if there is a specified lookup.
            Level2EventLogEntryType entryType = m_levelMapping.Lookup(level) as Level2EventLogEntryType;
            if (entryType != null)
            {
                return entryType.EventLogEntryType;
            }

            // Use default behavior

            if (level >= Level.Error)
            {
                return EventLogEntryType.Error;
            }
            else if (level == Level.Warn)
            {
                return EventLogEntryType.Warning;
            }

            // Default setting
            return EventLogEntryType.Information;
        }

        #endregion // Protected Instance Methods

        #region Private Instance Fields

        /// <summary>
        /// The log name is the section in the event logs where the messages
        /// are stored.
        /// </summary>
        private string m_logName;

        /// <summary>
        /// Name of the application to use when logging.  This appears in the
        /// application column of the event log named by <see cref="m_logName"/>.
        /// </summary>
        private string m_applicationName;

        /// <summary>
        /// The name of the machine which holds the event log. This is
        /// currently only allowed to be '.' i.e. the current machine.
        /// </summary>
        private string m_machineName;

        /// <summary>
        /// Mapping from level object to EventLogEntryType
        /// </summary>
        private LevelMapping m_levelMapping = new LevelMapping();

        /// <summary>
        /// The security context to use for privileged calls
        /// </summary>
        private SecurityContext m_securityContext;

        /// <summary>
        /// The event ID to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
        /// </summary>
        private int m_eventId = 0;

        /// <summary>
        /// The event category to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
        /// </summary>
        private short m_category = 0;

        #endregion // Private Instance Fields

        #region Level2EventLogEntryType LevelMapping Entry

        /// <summary>
        /// A class to act as a mapping between the level that a logging call is made at and
        /// the color it should be displayed as.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Defines the mapping between a level and its event log entry type.
        /// </para>
        /// </remarks>
        public class Level2EventLogEntryType : LevelMappingEntry
        {
            private EventLogEntryType m_entryType;

            /// <summary>
            /// The <see cref="EventLogEntryType"/> for this entry
            /// </summary>
            /// <remarks>
            /// <para>
            /// Required property.
            /// The <see cref="EventLogEntryType"/> for this entry
            /// </para>
            /// </remarks>
            public EventLogEntryType EventLogEntryType
            {
                get { return m_entryType; }
                set { m_entryType = value; }
            }
        }

        #endregion // LevelColors LevelMapping Entry

        #region Private Static Fields

        /// <summary>
        /// The fully qualified type of the EventLogAppender class.
        /// </summary>
        /// <remarks>
        /// Used by the internal logger to record the Type of the
        /// log message.
        /// </remarks>
        private readonly static Type declaringType = typeof(EventLogAppender);

        #endregion Private Static Fields
    }
}

#endif // !SSCLI
#endif // !NETCF
